home *** CD-ROM | disk | FTP | other *** search
/ MACD 5 / MACD 5.bin / workbench / libs / usergrouplib.lha / usergroup / crypt.c < prev    next >
C/C++ Source or Header  |  1992-09-02  |  35KB  |  1,106 lines
  1. RCS_ID_C="$Id: crypt.c,v 4.1 1994/05/16 14:09:07 ppessi Exp $";
  2. /*
  3.  * crypt.c --- password encryption
  4.  *
  5.  * This file is part of the AmiTCP/IP usergroup.library.
  6.  *
  7.  * Copyright © 1993 AmiTCP/IP Group, <AmiTCP-Group@hut.fi>
  8.  *                  Helsinki University of Technology, Finland.
  9.  *
  10.  * Created      : Wed Sep 15 01:25:26 1993 ppessi
  11.  * Last modified: Mon May 16 01:56:59 1994 ppessi
  12.  */
  13.  
  14. /* static char sccsid[] = "@(#)crypt.c    5.11 (Berkeley) 6/25/91"; */
  15.  
  16. /*
  17.  * Copyright (c) 1989 The Regents of the University of California.
  18.  * All rights reserved.
  19.  *
  20.  * This code is derived from software contributed to Berkeley by
  21.  * Tom Truscott.
  22.  *
  23.  * Redistribution and use in source and binary forms, with or without
  24.  * modification, are permitted provided that the following conditions
  25.  * are met:
  26.  * 1. Redistributions of source code must retain the above copyright
  27.  *    notice, this list of conditions and the following disclaimer.
  28.  * 2. Redistributions in binary form must reproduce the above copyright
  29.  *    notice, this list of conditions and the following disclaimer in the
  30.  *    documentation and/or other materials provided with the distribution.
  31.  * 3. All advertising materials mentioning features or use of this software
  32.  *    must display the following acknowledgement:
  33.  *    This product includes software developed by the University of
  34.  *    California, Berkeley and its contributors.
  35.  * 4. Neither the name of the University nor the names of its contributors
  36.  *    may be used to endorse or promote products derived from this software
  37.  *    without specific prior written permission.
  38.  *
  39.  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  40.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  41.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  42.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  43.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  44.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  45.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  46.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  47.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  48.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  49.  * SUCH DAMAGE.
  50.  */
  51.  
  52.  
  53. /****** usergroup.library/crypt ********************************************
  54.  
  55.     NAME
  56.         crypt - password encryption with DES
  57.  
  58.     SYNOPSIS
  59.        result = crypt(key, setting);
  60.          D0           A0     A1
  61.  
  62.        char *crypt(const char *, const char *)
  63.  
  64.     FUNCTION
  65.         The crypt function performs password encryption.  It is derived from
  66.         the NBS Data Encryption Standard.  Additional code has been added to
  67.         deter key search attempts.  
  68.  
  69.     INPUTS
  70.         key - a NUL-terminated string (normally a password typed by a user).
  71.  
  72.         setting - a character array, 9 bytes in length, consisting of an
  73.                   underscore (`_') followed by 4 bytes of iteration count
  74.                   and 4 bytes of salt.  Both the iteration count and the
  75.                   salt are encoded with 6 bits per character, least
  76.                   significant bits first.  The values 0 to 63 are encoded by
  77.                   the characters `./0-9A-Za-z', respectively.
  78.  
  79.         The salt is used to induce disorder in to the DES algorithm in one
  80.         of 16777216 possible ways (specifically, if bit i of the salt is set
  81.         then bits i and i+24 are swapped in the DES `E' box output).  The
  82.         key is divided into groups of 8 characters (a short final group is
  83.         null-padded) and the low-order 7 bits of each each character (56
  84.         bits per group) are used to form the DES key as follows: the first
  85.         group of 56 bits becomes the initial DES key.  For each additional
  86.         group, the XOR of the group bits and the encryption of the DES key
  87.         with itself becomes the next DES key.  Then the final DES key is
  88.         used to perform count cumulative encryptions of a 64-bit constant.
  89.  
  90.     RESULTS
  91.         result - a NUL-terminated string, 20 bytes in length, consisting of
  92.                  the setting followed by the encoded 64-bit encryption.
  93.  
  94.     NOTE
  95.         For compatibility with Version 7 UNIX version of crypt(), the
  96.         setting may consist of 2 bytes of salt, encoded as above, in which
  97.         case an iteration count of 25 is used, fewer perturbations of DES
  98.         are available, at most 8 characters of key are used, and the
  99.         returned value is a NUL-terminated string 13 bytes in length.
  100.  
  101.     HISTORY
  102.         A rotor-based crypt() function appeared in Version 6 AT&T UNIX.  The
  103.         current style crypt() first appeared in Version 7 AT&T UNIX.
  104.  
  105.     BUGS
  106.         The crypt() function leaves its result in an internal static object
  107.         and returns a pointer to that object.  Subsequent calls to crypt()
  108.         will modify the same object.
  109.  
  110.     SEE ALSO
  111.         netutil/login, netutil/passwd, getpass(), netinfo.device/passwd
  112.  
  113.         Wayne Patterson, Mathematical Cryptology for Computer Scientists and
  114.         Mathematicians, ISBN 0-8476-7438-X, 1987.
  115.  
  116.         R. Morris, and Ken Thompson, "Password Security: A Case History",
  117.         Communications of the ACM, vol. 22, pp. 594-597, Nov. 1979.
  118.  
  119.         M.E. Hellman, "DES will be Totally Insecure within Ten Years", IEEE
  120.         Spectrum, vol. 16, pp. 32-39, July 1979.
  121.  
  122. ****************************************************************************
  123. */
  124.  
  125. #include <sys/errno.h>
  126. #include <assert.h>
  127.  
  128. #include "base.h"
  129. #include "libfunc.h"
  130.  
  131. #include <limits.h>
  132.  
  133. /*
  134.  * UNIX password, and DES, encryption.
  135.  * By Tom Truscott, trt@rti.rti.org,
  136.  * from algorithms by Robert W. Baldwin and James Gillogly.
  137.  *
  138.  * References:
  139.  * "Mathematical Cryptology for Computer Scientists and Mathematicians,"
  140.  * by Wayne Patterson, 1987, ISBN 0-8476-7438-X.
  141.  *
  142.  * "Password Security: A Case History," R. Morris and Ken Thompson,
  143.  * Communications of the ACM, vol. 22, pp. 594-597, Nov. 1979.
  144.  *
  145.  * "DES will be Totally Insecure within Ten Years," M.E. Hellman,
  146.  * IEEE Spectrum, vol. 16, pp. 32-39, July 1979.
  147.  */
  148.  
  149. /* =====  Configuration ==================== */
  150.  
  151. /*
  152.  * define "MUST_ALIGN" if your compiler cannot load/store
  153.  * long integers at arbitrary (e.g. odd) memory locations.
  154.  * (Either that or never pass unaligned addresses to des_cipher!)
  155.  */
  156. #if !defined(vax)
  157. #define    MUST_ALIGN
  158. #endif
  159.  
  160. #ifdef CHAR_BITS
  161. #if CHAR_BITS != 8
  162.     #error C_block structure assumes 8 bit characters
  163. #endif
  164. #endif
  165.  
  166. /*
  167.  * define "LONG_IS_32_BITS" only if sizeof(long)==4.
  168.  * This avoids use of bit fields (your compiler may be sloppy with them).
  169.  */
  170. #if !defined(cray)
  171. #define    LONG_IS_32_BITS
  172. #endif
  173.  
  174. /*
  175.  * define "B64" to be the declaration for a 64 bit integer.
  176.  * XXX this feature is currently unused, see "endian" comment below.
  177.  */
  178. #if defined(cray)
  179. #define    B64    long
  180. #endif
  181. #if defined(convex)
  182. #define    B64    long long
  183. #endif
  184.  
  185. /*
  186.  * define "LARGEDATA" to get faster permutations, by using about 72 kilobytes
  187.  * of lookup tables.  This speeds up des_setkey() and des_cipher(), but has
  188.  * little effect on crypt().
  189.  */
  190. #if defined(notdef)
  191. #define    LARGEDATA
  192. #endif
  193.  
  194. /* compile with "-DSTATIC" when profiling */
  195. #ifndef STATIC
  196. #define    STATIC    static
  197. #endif
  198.  
  199. #ifdef DEBUG
  200. STATIC void prtab(char *s, unsigned char *t, int num_rows);
  201. #endif
  202.  
  203. /* ==================================== */
  204.  
  205. /*
  206.  * Cipher-block representation (Bob Baldwin):
  207.  *
  208.  * DES operates on groups of 64 bits, numbered 1..64 (sigh).  One
  209.  * representation is to store one bit per byte in an array of bytes.  Bit N of
  210.  * the NBS spec is stored as the LSB of the Nth byte (index N-1) in the array.
  211.  * Another representation stores the 64 bits in 8 bytes, with bits 1..8 in the
  212.  * first byte, 9..16 in the second, and so on.  The DES spec apparently has
  213.  * bit 1 in the MSB of the first byte, but that is particularly noxious so we
  214.  * bit-reverse each byte so that bit 1 is the LSB of the first byte, bit 8 is
  215.  * the MSB of the first byte.  Specifically, the 64-bit input data and key are
  216.  * converted to LSB format, and the output 64-bit block is converted back into
  217.  * MSB format.
  218.  *
  219.  * DES operates internally on groups of 32 bits which are expanded to 48 bits
  220.  * by permutation E and shrunk back to 32 bits by the S boxes.  To speed up
  221.  * the computation, the expansion is applied only once, the expanded
  222.  * representation is maintained during the encryption, and a compression
  223.  * permutation is applied only at the end.  To speed up the S-box lookups,
  224.  * the 48 bits are maintained as eight 6 bit groups, one per byte, which
  225.  * directly feed the eight S-boxes.  Within each byte, the 6 bits are the
  226.  * most significant ones.  The low two bits of each byte are zero.  (Thus,
  227.  * bit 1 of the 48 bit E expansion is stored as the "4"-valued bit of the
  228.  * first byte in the eight byte representation, bit 2 of the 48 bit value is
  229.  * the "8"-valued bit, and so on.)  In fact, a combined "SPE"-box lookup is
  230.  * used, in which the output is the 64 bit result of an S-box lookup which
  231.  * has been permuted by P and expanded by E, and is ready for use in the next
  232.  * iteration.  Two 32-bit wide tables, SPE[0] and SPE[1], are used for this
  233.  * lookup.  Since each byte in the 48 bit path is a multiple of four, indexed
  234.  * lookup of SPE[0] and SPE[1] is simple and fast.  The key schedule and
  235.  * "salt" are also converted to this 8*(6+2) format.  The SPE table size is
  236.  * 8*64*8 = 4K bytes.
  237.  *
  238.  * To speed up bit-parallel operations (such as XOR), the 8 byte
  239.  * representation is "union"ed with 32 bit values "i0" and "i1", and, on
  240.  * machines which support it, a 64 bit value "b64".  This data structure,
  241.  * "C_block", has two problems.  First, alignment restrictions must be
  242.  * honored.  Second, the byte-order (e.g. little-endian or big-endian) of
  243.  * the architecture becomes visible.
  244.  *
  245.  * The byte-order problem is unfortunate, since on the one hand it is good
  246.  * to have a machine-independent C_block representation (bits 1..8 in the
  247.  * first byte, etc.), and on the other hand it is good for the LSB of the
  248.  * first byte to be the LSB of i0.  We cannot have both these things, so we
  249.  * currently use the "little-endian" representation and avoid any multi-byte
  250.  * operations that depend on byte order.  This largely precludes use of the
  251.  * 64-bit datatype since the relative order of i0 and i1 are unknown.  It
  252.  * also inhibits grouping the SPE table to look up 12 bits at a time.  (The
  253.  * 12 bits can be stored in a 16-bit field with 3 low-order zeroes and 1
  254.  * high-order zero, providing fast indexing into a 64-bit wide SPE.)  On the
  255.  * other hand, 64-bit datatypes are currently rare, and a 12-bit SPE lookup
  256.  * requires a 128 kilobyte table, so perhaps this is not a big loss.
  257.  *
  258.  * Permutation representation (Jim Gillogly):
  259.  *
  260.  * A transformation is defined by its effect on each of the 8 bytes of the
  261.  * 64-bit input.  For each byte we give a 64-bit output that has the bits in
  262.  * the input distributed appropriately.  The transformation is then the OR
  263.  * of the 8 sets of 64-bits.  This uses 8*256*8 = 16K bytes of storage for
  264.  * each transformation.  Unless LARGEDATA is defined, however, a more compact
  265.  * table is used which looks up 16 4-bit "chunks" rather than 8 8-bit chunks.
  266.  * The smaller table uses 16*16*8 = 2K bytes for each transformation.  This
  267.  * is slower but tolerable, particularly for password encryption in which
  268.  * the SPE transformation is iterated many times.  The small tables total 9K
  269.  * bytes, the large tables total 72K bytes.
  270.  *
  271.  * The transformations used are:
  272.  * IE3264: MSB->LSB conversion, initial permutation, and expansion.
  273.  *    This is done by collecting the 32 even-numbered bits and applying
  274.  *    a 32->64 bit transformation, and then collecting the 32 odd-numbered
  275.  *    bits and applying the same transformation.  Since there are only
  276.  *    32 input bits, the IE3264 transformation table is half the size of
  277.  *    the usual table.
  278.  * CF6464: Compression, final permutation, and LSB->MSB conversion.
  279.  *    This is done by two trivial 48->32 bit compressions to obtain
  280.  *    a 64-bit block (the bit numbering is given in the "CIFP" table)
  281.  *    followed by a 64->64 bit "cleanup" transformation.  (It would
  282.  *    be possible to group the bits in the 64-bit block so that 2
  283.  *    identical 32->32 bit transformations could be used instead,
  284.  *    saving a factor of 4 in space and possibly 2 in time, but
  285.  *    byte-ordering and other complications rear their ugly head.
  286.  *    Similar opportunities/problems arise in the key schedule
  287.  *    transforms.)
  288.  * PC1ROT: MSB->LSB, PC1 permutation, rotate, and PC2 permutation.
  289.  *    This admittedly baroque 64->64 bit transformation is used to
  290.  *    produce the first code (in 8*(6+2) format) of the key schedule.
  291.  * PC2ROT[0]: Inverse PC2 permutation, rotate, and PC2 permutation.
  292.  *    It would be possible to define 15 more transformations, each
  293.  *    with a different rotation, to generate the entire key schedule.
  294.  *    To save space, however, we instead permute each code into the
  295.  *    next by using a transformation that "undoes" the PC2 permutation,
  296.  *    rotates the code, and then applies PC2.  Unfortunately, PC2
  297.  *    transforms 56 bits into 48 bits, dropping 8 bits, so PC2 is not
  298.  *    invertible.  We get around that problem by using a modified PC2
  299.  *    which retains the 8 otherwise-lost bits in the unused low-order
  300.  *    bits of each byte.  The low-order bits are cleared when the
  301.  *    codes are stored into the key schedule.
  302.  * PC2ROT[1]: Same as PC2ROT[0], but with two rotations.
  303.  *    This is faster than applying PC2ROT[0] twice,
  304.  *
  305.  * The Bell Labs "salt" (Bob Baldwin):
  306.  *
  307.  * The salting is a simple permutation applied to the 48-bit result of E.
  308.  * Specifically, if bit i (1 <= i <= 24) of the salt is set then bits i and
  309.  * i+24 of the result are swapped.  The salt is thus a 24 bit number, with
  310.  * 16777216 possible values.  (The original salt was 12 bits and could not
  311.  * swap bits 13..24 with 36..48.)
  312.  *
  313.  * It is possible, but ugly, to warp the SPE table to account for the salt
  314.  * permutation.  Fortunately, the conditional bit swapping requires only
  315.  * about four machine instructions and can be done on-the-fly with about an
  316.  * 8% performance penalty.
  317.  */
  318.  
  319. typedef union {
  320.     unsigned char b[8];
  321.     struct {
  322. #if defined(LONG_IS_32_BITS)
  323.         /* long is often faster than a 32-bit bit field */
  324.         long    i0;
  325.         long    i1;
  326. #else
  327.         long    i0: 32;
  328.         long    i1: 32;
  329. #endif
  330.     } b32;
  331. #if defined(B64)
  332.     B64    b64;
  333. #endif
  334. } C_block;
  335.  
  336. /*
  337.  * Convert twenty-four-bit long in host-order
  338.  * to six bits (and 2 low-order zeroes) per char little-endian format.
  339.  */
  340. #define    TO_SIX_BIT(rslt, src) {                \
  341.         C_block cvt;                \
  342.         cvt.b[0] = src; src >>= 6;        \
  343.         cvt.b[1] = src; src >>= 6;        \
  344.         cvt.b[2] = src; src >>= 6;        \
  345.         cvt.b[3] = src;                \
  346.         rslt = (cvt.b32.i0 & 0x3f3f3f3fL) << 2;    \
  347.     }
  348.  
  349. /*
  350.  * These macros may someday permit efficient use of 64-bit integers.
  351.  */
  352. #define    ZERO(d,d0,d1)            d0 = 0, d1 = 0
  353. #define    LOAD(d,d0,d1,bl)        d0 = (bl).b32.i0, d1 = (bl).b32.i1
  354. #define    LOADREG(d,d0,d1,s,s0,s1)    d0 = s0, d1 = s1
  355. #define    OR(d,d0,d1,bl)            d0 |= (bl).b32.i0, d1 |= (bl).b32.i1
  356. #define    STORE(s,s0,s1,bl)        (bl).b32.i0 = s0, (bl).b32.i1 = s1
  357. #define    DCL_BLOCK(d,d0,d1)        long d0, d1
  358.  
  359. #if defined(LARGEDATA)
  360.     /* Waste memory like crazy.  Also, do permutations in line */
  361. #define    LGCHUNKBITS    3
  362. #define    CHUNKBITS    (1<<LGCHUNKBITS)
  363. #define    PERM6464(d,d0,d1,cpp,p)                \
  364.     LOAD(d,d0,d1,(p)[(0<<CHUNKBITS)+(cpp)[0]]);        \
  365.     OR (d,d0,d1,(p)[(1<<CHUNKBITS)+(cpp)[1]]);        \
  366.     OR (d,d0,d1,(p)[(2<<CHUNKBITS)+(cpp)[2]]);        \
  367.     OR (d,d0,d1,(p)[(3<<CHUNKBITS)+(cpp)[3]]);        \
  368.     OR (d,d0,d1,(p)[(4<<CHUNKBITS)+(cpp)[4]]);        \
  369.     OR (d,d0,d1,(p)[(5<<CHUNKBITS)+(cpp)[5]]);        \
  370.     OR (d,d0,d1,(p)[(6<<CHUNKBITS)+(cpp)[6]]);        \
  371.     OR (d,d0,d1,(p)[(7<<CHUNKBITS)+(cpp)[7]]);
  372. #define    PERM3264(d,d0,d1,cpp,p)                \
  373.     LOAD(d,d0,d1,(p)[(0<<CHUNKBITS)+(cpp)[0]]);        \
  374.     OR (d,d0,d1,(p)[(1<<CHUNKBITS)+(cpp)[1]]);        \
  375.     OR (d,d0,d1,(p)[(2<<CHUNKBITS)+(cpp)[2]]);        \
  376.     OR (d,d0,d1,(p)[(3<<CHUNKBITS)+(cpp)[3]]);
  377. #else
  378.     /* "small data" */
  379. #define    LGCHUNKBITS    2
  380. #define    CHUNKBITS    (1<<LGCHUNKBITS)
  381. #define    PERM6464(d,d0,d1,cpp,p)                \
  382.     { C_block tblk; permute(cpp,&tblk,p,8); LOAD (d,d0,d1,tblk); }
  383. #define    PERM3264(d,d0,d1,cpp,p)                \
  384.     { C_block tblk; permute(cpp,&tblk,p,4); LOAD (d,d0,d1,tblk); }
  385.  
  386. STATIC void permute(unsigned char *cp,
  387.             C_block *out,
  388.             register C_block *p,
  389.             int chars_in)
  390. {
  391.     register DCL_BLOCK(D,D0,D1);
  392.     register C_block *tp;
  393.     register int t;
  394.  
  395.     ZERO(D,D0,D1);
  396.     do {
  397.         t = *cp++;
  398.         tp = &p[t&0xf]; OR(D,D0,D1,*tp); p += (1<<CHUNKBITS);
  399.         tp = &p[t>>4];  OR(D,D0,D1,*tp); p += (1<<CHUNKBITS);
  400.     } while (--chars_in > 0);
  401.     STORE(D,D0,D1,*out);
  402. }
  403. #endif /* LARGEDATA */
  404.  
  405. /*STATIC*/ void init_des(void);
  406. STATIC void init_perm(C_block perm[64/CHUNKBITS][1<<CHUNKBITS],
  407.               unsigned char p[64],
  408.               int chars_in,
  409.               int chars_out);
  410. STATIC int des_setkey(register const char *key);
  411. STATIC int des_cipher(const char *in, char *out, long salt, int num_iter);
  412.  
  413. /* =====  (mostly) Standard DES Tables ==================== */
  414.  
  415. /* initial permutation */
  416. static const unsigned char IP[] = {
  417.     58, 50, 42, 34, 26, 18, 10,  2,
  418.     60, 52, 44, 36, 28, 20, 12,  4,
  419.     62, 54, 46, 38, 30, 22, 14,  6,
  420.     64, 56, 48, 40, 32, 24, 16,  8,
  421.     57, 49, 41, 33, 25, 17,  9,  1,
  422.     59, 51, 43, 35, 27, 19, 11,  3,
  423.     61, 53, 45, 37, 29, 21, 13,  5,
  424.     63, 55, 47, 39, 31, 23, 15,  7,
  425. };
  426.  
  427. /* The final permutation is the inverse of IP - no table is necessary */
  428.  
  429. /* expansion operation */
  430. static const unsigned char ExpandTr[] = {
  431.     32,  1,  2,  3,  4,  5,
  432.      4,  5,  6,  7,  8,  9,
  433.      8,  9, 10, 11, 12, 13,
  434.     12, 13, 14, 15, 16, 17,
  435.     16, 17, 18, 19, 20, 21,
  436.     20, 21, 22, 23, 24, 25,
  437.     24, 25, 26, 27, 28, 29,
  438.     28, 29, 30, 31, 32,  1,
  439. };
  440.  
  441. /* permuted choice table 1 */
  442. static const unsigned char PC1[] = {
  443.     57, 49, 41, 33, 25, 17,  9,
  444.      1, 58, 50, 42, 34, 26, 18,
  445.     10,  2, 59, 51, 43, 35, 27,
  446.     19, 11,  3, 60, 52, 44, 36,
  447.  
  448.     63, 55, 47, 39, 31, 23, 15,
  449.      7, 62, 54, 46, 38, 30, 22,
  450.     14,  6, 61, 53, 45, 37, 29,
  451.     21, 13,  5, 28, 20, 12,  4,
  452. };
  453.  
  454. static const unsigned char Rotates[] = {/* PC1 rotation schedule */
  455.     1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1,
  456. };
  457.  
  458. /* note: each "row" of PC2 is left-padded with bits that make it invertible */
  459. static const unsigned char PC2[] = {    /* permuted choice table 2 */
  460.      9, 18,    14, 17, 11, 24,  1,  5,
  461.     22, 25,     3, 28, 15,  6, 21, 10,
  462.     35, 38,    23, 19, 12,  4, 26,  8,
  463.     43, 54,    16,  7, 27, 20, 13,  2,
  464.  
  465.      0,  0,    41, 52, 31, 37, 47, 55,
  466.      0,  0,    30, 40, 51, 45, 33, 48,
  467.      0,  0,    44, 49, 39, 56, 34, 53,
  468.      0,  0,    46, 42, 50, 36, 29, 32,
  469. };
  470.  
  471. static const unsigned char S[8][64] = {    /* 48->32 bit substitution tables */
  472.                     /* S[1]            */
  473.     14,  4, 13,  1,  2, 15, 11,  8,  3, 10,  6, 12,  5,  9,  0,  7,
  474.      0, 15,  7,  4, 14,  2, 13,  1, 10,  6, 12, 11,  9,  5,  3,  8,
  475.      4,  1, 14,  8, 13,  6,  2, 11, 15, 12,  9,  7,  3, 10,  5,  0,
  476.     15, 12,  8,  2,  4,  9,  1,  7,  5, 11,  3, 14, 10,  0,  6, 13,
  477.                     /* S[2]            */
  478.     15,  1,  8, 14,  6, 11,  3,  4,  9,  7,  2, 13, 12,  0,  5, 10,
  479.      3, 13,  4,  7, 15,  2,  8, 14, 12,  0,  1, 10,  6,  9, 11,  5,
  480.      0, 14,  7, 11, 10,  4, 13,  1,  5,  8, 12,  6,  9,  3,  2, 15,
  481.     13,  8, 10,  1,  3, 15,  4,  2, 11,  6,  7, 12,  0,  5, 14,  9,
  482.                     /* S[3]            */
  483.     10,  0,  9, 14,  6,  3, 15,  5,  1, 13, 12,  7, 11,  4,  2,  8,
  484.     13,  7,  0,  9,  3,  4,  6, 10,  2,  8,  5, 14, 12, 11, 15,  1,
  485.     13,  6,  4,  9,  8, 15,  3,  0, 11,  1,  2, 12,  5, 10, 14,  7,
  486.      1, 10, 13,  0,  6,  9,  8,  7,  4, 15, 14,  3, 11,  5,  2, 12,
  487.                     /* S[4]            */
  488.      7, 13, 14,  3,  0,  6,  9, 10,  1,  2,  8,  5, 11, 12,  4, 15,
  489.     13,  8, 11,  5,  6, 15,  0,  3,  4,  7,  2, 12,  1, 10, 14,  9,
  490.     10,  6,  9,  0, 12, 11,  7, 13, 15,  1,  3, 14,  5,  2,  8,  4,
  491.      3, 15,  0,  6, 10,  1, 13,  8,  9,  4,  5, 11, 12,  7,  2, 14,
  492.                     /* S[5]            */
  493.      2, 12,  4,  1,  7, 10, 11,  6,  8,  5,  3, 15, 13,  0, 14,  9,
  494.     14, 11,  2, 12,  4,  7, 13,  1,  5,  0, 15, 10,  3,  9,  8,  6,
  495.      4,  2,  1, 11, 10, 13,  7,  8, 15,  9, 12,  5,  6,  3,  0, 14,
  496.     11,  8, 12,  7,  1, 14,  2, 13,  6, 15,  0,  9, 10,  4,  5,  3,
  497.                     /* S[6]            */
  498.     12,  1, 10, 15,  9,  2,  6,  8,  0, 13,  3,  4, 14,  7,  5, 11,
  499.     10, 15,  4,  2,  7, 12,  9,  5,  6,  1, 13, 14,  0, 11,  3,  8,
  500.      9, 14, 15,  5,  2,  8, 12,  3,  7,  0,  4, 10,  1, 13, 11,  6,
  501.      4,  3,  2, 12,  9,  5, 15, 10, 11, 14,  1,  7,  6,  0,  8, 13,
  502.                     /* S[7]            */
  503.      4, 11,  2, 14, 15,  0,  8, 13,  3, 12,  9,  7,  5, 10,  6,  1,
  504.     13,  0, 11,  7,  4,  9,  1, 10, 14,  3,  5, 12,  2, 15,  8,  6,
  505.      1,  4, 11, 13, 12,  3,  7, 14, 10, 15,  6,  8,  0,  5,  9,  2,
  506.      6, 11, 13,  8,  1,  4, 10,  7,  9,  5,  0, 15, 14,  2,  3, 12,
  507.                     /* S[8]            */
  508.     13,  2,  8,  4,  6, 15, 11,  1, 10,  9,  3, 14,  5,  0, 12,  7,
  509.      1, 15, 13,  8, 10,  3,  7,  4, 12,  5,  6, 11,  0, 14,  9,  2,
  510.      7, 11,  4,  1,  9, 12, 14,  2,  0,  6, 10, 13, 15,  3,  5,  8,
  511.      2,  1, 14,  7,  4, 10,  8, 13, 15, 12,  9,  0,  3,  5,  6, 11,
  512. };
  513.  
  514. /* 32-bit permutation function */
  515. static const unsigned char P32Tr[] = {
  516.     16,  7, 20, 21,
  517.     29, 12, 28, 17,
  518.      1, 15, 23, 26,
  519.      5, 18, 31, 10,
  520.      2,  8, 24, 14,
  521.     32, 27,  3,  9,
  522.     19, 13, 30,  6,
  523.     22, 11,  4, 25,
  524. };
  525.  
  526. /* compressed/interleaved permutation */
  527. static const unsigned char CIFP[] = {
  528.      1,  2,  3,  4,   17, 18, 19, 20,
  529.      5,  6,  7,  8,   21, 22, 23, 24,
  530.      9, 10, 11, 12,   25, 26, 27, 28,
  531.     13, 14, 15, 16,   29, 30, 31, 32,
  532.  
  533.     33, 34, 35, 36,   49, 50, 51, 52,
  534.     37, 38, 39, 40,   53, 54, 55, 56,
  535.     41, 42, 43, 44,   57, 58, 59, 60,
  536.     45, 46, 47, 48,   61, 62, 63, 64,
  537. };
  538.  
  539. static const unsigned char itoa64[] =        /* 0..63 => ascii-64 */
  540.     "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
  541.  
  542.  
  543. /* =====  Tables that are initialized at run time  ==================== */
  544. /* Note: these are stored into FAR section which is not duplicated */
  545.  
  546. FAR static unsigned char a64toi[128];    /* ascii-64 => 0..63 */
  547.  
  548. /* Initial key schedule permutation */
  549. FAR static C_block    PC1ROT[64/CHUNKBITS][1<<CHUNKBITS];
  550.  
  551. /* Subsequent key schedule rotation permutations */
  552. FAR static C_block    PC2ROT[2][64/CHUNKBITS][1<<CHUNKBITS];
  553.  
  554. /* Initial permutation/expansion table */
  555. FAR static C_block    IE3264[32/CHUNKBITS][1<<CHUNKBITS];
  556.  
  557. /* Table that combines the S, P, and E operations.  */
  558. FAR static long SPE[2][8][64];
  559.  
  560. /* compressed/interleaved => final permutation table */
  561. FAR static C_block    CF6464[64/CHUNKBITS][1<<CHUNKBITS];
  562.  
  563.  
  564. /* ==================================== */
  565.  
  566.  
  567. static C_block    constdatablock;            /* encryption constant */
  568. static char    cryptresult[1+4+4+11+1];    /* encrypted result */
  569.  
  570. /*
  571.  * Return a pointer to provided buffer consisting of the "setting"
  572.  * followed by an encryption produced by the "key" and "setting".
  573.  */
  574. SAVEDS ASM char *R_crypt(REG(a0) const char *key,
  575.              REG(a1) const char *setting)
  576. {
  577.     register char *encp;
  578.     register long i;
  579.     register int t;
  580.     long salt;
  581.     int num_iter, salt_size;
  582.     C_block keyblock, rsltblock;
  583.  
  584.     for (i = 0; i < 8; i++) {
  585.         if ((t = 2*(unsigned char)(*key)) != 0)
  586.             key++;
  587.         keyblock.b[i] = t;
  588.     }
  589.     if (des_setkey((char *)keyblock.b))
  590.         return (NULL);
  591.  
  592.     encp = &cryptresult[0];
  593.     switch (*setting) {
  594.     case _PASSWORD_EFMT1:
  595.         /*
  596.          * Involve the rest of the password 8 characters at a time.
  597.          */
  598.         while (*key) {
  599.             if (des_cipher((char *)&keyblock,
  600.                 (char *)&keyblock, 0L, 1))
  601.                 return (NULL);
  602.             for (i = 0; i < 8; i++) {
  603.                 if ((t = 2*(unsigned char)(*key)) != 0)
  604.                     key++;
  605.                 keyblock.b[i] ^= t;
  606.             }
  607.             if (des_setkey((char *)keyblock.b))
  608.                 return (NULL);
  609.         }
  610.  
  611.         *encp++ = *setting++;
  612.  
  613.         /* get iteration count */
  614.         num_iter = 0;
  615.         for (i = 4; --i >= 0; ) {
  616.             if ((t = (unsigned char)setting[i]) == '\0')
  617.                 t = '.';
  618.             encp[i] = t;
  619.             num_iter = (num_iter<<6) | a64toi[t];
  620.         }
  621.         setting += 4;
  622.         encp += 4;
  623.         salt_size = 4;
  624.         break;
  625.     default:
  626.         num_iter = 25;
  627.         salt_size = 2;
  628.     }
  629.  
  630.     salt = 0;
  631.     for (i = salt_size; --i >= 0; ) {
  632.         if ((t = (unsigned char)setting[i]) == '\0')
  633.             t = '.';
  634.         encp[i] = t;
  635.         salt = (salt<<6) | a64toi[t];
  636.     }
  637.     encp += salt_size;
  638.     if (des_cipher((char *)&constdatablock, (char *)&rsltblock,
  639.         salt, num_iter))
  640.         return (NULL);
  641.  
  642.     /*
  643.      * Encode the 64 cipher bits as 11 ascii characters.
  644.      */
  645.     i = ((long)((rsltblock.b[0]<<8) | rsltblock.b[1])<<8) | rsltblock.b[2];
  646.     encp[3] = itoa64[i&0x3f];    i >>= 6;
  647.     encp[2] = itoa64[i&0x3f];    i >>= 6;
  648.     encp[1] = itoa64[i&0x3f];    i >>= 6;
  649.     encp[0] = itoa64[i];        encp += 4;
  650.     i = ((long)((rsltblock.b[3]<<8) | rsltblock.b[4])<<8) | rsltblock.b[5];
  651.     encp[3] = itoa64[i&0x3f];    i >>= 6;
  652.     encp[2] = itoa64[i&0x3f];    i >>= 6;
  653.     encp[1] = itoa64[i&0x3f];    i >>= 6;
  654.     encp[0] = itoa64[i];        encp += 4;
  655.     i = ((long)((rsltblock.b[6])<<8) | rsltblock.b[7])<<2;
  656.     encp[2] = itoa64[i&0x3f];    i >>= 6;
  657.     encp[1] = itoa64[i&0x3f];    i >>= 6;
  658.     encp[0] = itoa64[i];
  659.  
  660.     encp[3] = 0;
  661.  
  662.     return (cryptresult);
  663. }
  664.  
  665.  
  666. /*
  667.  * The Key Schedule, filled in by des_setkey() or setkey().
  668.  */
  669. #define    KS_SIZE    16
  670. static C_block    KS[KS_SIZE];
  671.  
  672. /*
  673.  * Set up the key schedule from the key.
  674.  */
  675. STATIC int des_setkey(register const char *key)
  676. {
  677.     register DCL_BLOCK(K, K0, K1);
  678.     register C_block *ptabp;
  679.     register int i;
  680.     FAR static short des_ready = 0;
  681.  
  682.     if (!des_ready) {
  683.         init_des();
  684.         des_ready = 1;
  685.     }
  686.  
  687.     PERM6464(K,K0,K1,(unsigned char *)key,(C_block *)PC1ROT);
  688.     key = (char *)&KS[0];
  689.     STORE(K&~0x03030303L, K0&~0x03030303L, K1, *(C_block *)key);
  690.     for (i = 1; i < 16; i++) {
  691.         key += sizeof(C_block);
  692.         STORE(K,K0,K1,*(C_block *)key);
  693.         ptabp = (C_block *)PC2ROT[Rotates[i]-1];
  694.         PERM6464(K,K0,K1,(unsigned char *)key,ptabp);
  695.         STORE(K&~0x03030303L, K0&~0x03030303L, K1, *(C_block *)key);
  696.     }
  697.     return (0);
  698. }
  699.  
  700. /*
  701.  * Encrypt (or decrypt if num_iter < 0) the 8 chars at "in" with abs(num_iter)
  702.  * iterations of DES, using the the given 24-bit salt and the pre-computed key
  703.  * schedule, and store the resulting 8 chars at "out" (in == out is permitted).
  704.  *
  705.  * NOTE: the performance of this routine is critically dependent on your
  706.  * compiler and machine architecture.
  707.  */
  708. STATIC int des_cipher(const char *in, char *out, long salt, int num_iter)
  709. {
  710.     /* variables that we want in registers, most important first */
  711. #if defined(pdp11)
  712.     register int j;
  713. #endif
  714.     register long L0, L1, R0, R1, k;
  715.     register C_block *kp;
  716.     register int ks_inc, loop_count;
  717.     C_block B;
  718.  
  719.     L0 = salt;
  720.     TO_SIX_BIT(salt, L0);    /* convert to 4*(6+2) format */
  721.  
  722. #if defined(vax) || defined(pdp11)
  723.     salt = ~salt;    /* "x &~ y" is faster than "x & y". */
  724. #define    SALT (~salt)
  725. #else
  726. #define    SALT salt
  727. #endif
  728.  
  729. #if defined(MUST_ALIGN)
  730.     B.b[0] = in[0]; B.b[1] = in[1]; B.b[2] = in[2]; B.b[3] = in[3];
  731.     B.b[4] = in[4]; B.b[5] = in[5]; B.b[6] = in[6]; B.b[7] = in[7];
  732.     LOAD(L,L0,L1,B);
  733. #else
  734.     LOAD(L,L0,L1,*(C_block *)in);
  735. #endif
  736.     LOADREG(R,R0,R1,L,L0,L1);
  737.     L0 &= 0x55555555L;
  738.     L1 &= 0x55555555L;
  739.     L0 = (L0 << 1) | L1;    /* L0 is the even-numbered input bits */
  740.     R0 &= 0xaaaaaaaaL;
  741.     R1 = (R1 >> 1) & 0x55555555L;
  742.     L1 = R0 | R1;        /* L1 is the odd-numbered input bits */
  743.     STORE(L,L0,L1,B);
  744.     PERM3264(L,L0,L1,B.b,  (C_block *)IE3264);    /* even bits */
  745.     PERM3264(R,R0,R1,B.b+4,(C_block *)IE3264);    /* odd bits */
  746.  
  747.     if (num_iter >= 0)
  748.     {        /* encryption */
  749.         kp = &KS[0];
  750.         ks_inc  = sizeof(*kp);
  751.     }
  752.     else
  753.     {        /* decryption */
  754.         num_iter = -num_iter;
  755.         kp = &KS[KS_SIZE-1];
  756.         ks_inc  = -sizeof(*kp);
  757.     }
  758.  
  759.     while (--num_iter >= 0) {
  760.         loop_count = 8;
  761.         do {
  762.  
  763. #define    SPTAB(t, i)    (*(long *)((unsigned char *)t + i*(sizeof(long)/4)))
  764. #if defined(gould)
  765.             /* use this if B.b[i] is evaluated just once ... */
  766. #define    DOXOR(x,y,i)    x^=SPTAB(SPE[0][i],B.b[i]); y^=SPTAB(SPE[1][i],B.b[i]);
  767. #else
  768. #if defined(pdp11)
  769.             /* use this if your "long" int indexing is slow */
  770. #define    DOXOR(x,y,i)    j=B.b[i]; x^=SPTAB(SPE[0][i],j); y^=SPTAB(SPE[1][i],j);
  771. #else
  772.             /* use this if "k" is allocated to a register ... */
  773. #define    DOXOR(x,y,i)    k=B.b[i]; x^=SPTAB(SPE[0][i],k); y^=SPTAB(SPE[1][i],k);
  774. #endif
  775. #endif
  776.  
  777. #define    CRUNCH(p0, p1, q0, q1)    \
  778.             k = (q0 ^ q1) & SALT;    \
  779.             B.b32.i0 = k ^ q0 ^ kp->b32.i0;        \
  780.             B.b32.i1 = k ^ q1 ^ kp->b32.i1;        \
  781.             kp = (C_block *)((char *)kp+ks_inc);    \
  782.                             \
  783.             DOXOR(p0, p1, 0);        \
  784.             DOXOR(p0, p1, 1);        \
  785.             DOXOR(p0, p1, 2);        \
  786.             DOXOR(p0, p1, 3);        \
  787.             DOXOR(p0, p1, 4);        \
  788.             DOXOR(p0, p1, 5);        \
  789.             DOXOR(p0, p1, 6);        \
  790.             DOXOR(p0, p1, 7);
  791.  
  792.             CRUNCH(L0, L1, R0, R1);
  793.             CRUNCH(R0, R1, L0, L1);
  794.         } while (--loop_count != 0);
  795.         kp = (C_block *)((char *)kp-(ks_inc*KS_SIZE));
  796.  
  797.  
  798.         /* swap L and R */
  799.         L0 ^= R0;  L1 ^= R1;
  800.         R0 ^= L0;  R1 ^= L1;
  801.         L0 ^= R0;  L1 ^= R1;
  802.     }
  803.  
  804.     /* store the encrypted (or decrypted) result */
  805.     L0 = ((L0 >> 3) & 0x0f0f0f0fL) | ((L1 << 1) & 0xf0f0f0f0L);
  806.     L1 = ((R0 >> 3) & 0x0f0f0f0fL) | ((R1 << 1) & 0xf0f0f0f0L);
  807.     STORE(L,L0,L1,B);
  808.     PERM6464(L,L0,L1,B.b, (C_block *)CF6464);
  809. #if defined(MUST_ALIGN)
  810.     STORE(L,L0,L1,B);
  811.     out[0] = B.b[0]; out[1] = B.b[1]; out[2] = B.b[2]; out[3] = B.b[3];
  812.     out[4] = B.b[4]; out[5] = B.b[5]; out[6] = B.b[6]; out[7] = B.b[7];
  813. #else
  814.     STORE(L,L0,L1,*(C_block *)out);
  815. #endif
  816.     return (0);
  817. }
  818.  
  819.  
  820. /*
  821.  * Initialize various tables.  This need only be done once.  It could even be
  822.  * done at compile time, if the compiler were capable of that sort of thing.
  823.  */
  824. void init_des(void)
  825. {
  826.     register int i, j;
  827.     register long k;
  828.     register int tableno;
  829.     static unsigned char perm[64], tmp32[32];    /* "static" for speed */
  830.  
  831.     /*
  832.      * table that converts chars "./0-9A-Za-z"to integers 0-63.
  833.      */
  834.     for (i = 0; i < 64; i++)
  835.         a64toi[itoa64[i]] = i;
  836.  
  837.     /*
  838.      * PC1ROT - bit reverse, then PC1, then Rotate, then PC2.
  839.      */
  840.     for (i = 0; i < 64; i++)
  841.         perm[i] = 0;
  842.     for (i = 0; i < 64; i++) {
  843.         if ((k = PC2[i]) == 0)
  844.             continue;
  845.         k += Rotates[0]-1;
  846.         if ((k%28) < Rotates[0]) k -= 28;
  847.         k = PC1[k];
  848.         if (k > 0) {
  849.             k--;
  850.             k = (k|07) - (k&07);
  851.             k++;
  852.         }
  853.         perm[i] = k;
  854.     }
  855. #ifdef DEBUG
  856.     prtab("pc1tab", perm, 8);
  857. #endif
  858.     init_perm(PC1ROT, perm, 8, 8);
  859.  
  860.     /*
  861.      * PC2ROT - PC2 inverse, then Rotate (once or twice), then PC2.
  862.      */
  863.     for (j = 0; j < 2; j++) {
  864.         unsigned char pc2inv[64];
  865.         for (i = 0; i < 64; i++)
  866.             perm[i] = pc2inv[i] = 0;
  867.         for (i = 0; i < 64; i++) {
  868.             if ((k = PC2[i]) == 0)
  869.                 continue;
  870.             pc2inv[k-1] = i+1;
  871.         }
  872.         for (i = 0; i < 64; i++) {
  873.             if ((k = PC2[i]) == 0)
  874.                 continue;
  875.             k += j;
  876.             if ((k%28) <= j) k -= 28;
  877.             perm[i] = pc2inv[k];
  878.         }
  879. #ifdef DEBUG
  880.         prtab("pc2tab", perm, 8);
  881. #endif
  882.         init_perm(PC2ROT[j], perm, 8, 8);
  883.     }
  884.  
  885.     /*
  886.      * Bit reverse, then initial permutation, then expansion.
  887.      */
  888.     for (i = 0; i < 8; i++) {
  889.         for (j = 0; j < 8; j++) {
  890.             k = (j < 2)? 0: IP[ExpandTr[i*6+j-2]-1];
  891.             if (k > 32)
  892.                 k -= 32;
  893.             else if (k > 0)
  894.                 k--;
  895.             if (k > 0) {
  896.                 k--;
  897.                 k = (k|07) - (k&07);
  898.                 k++;
  899.             }
  900.             perm[i*8+j] = k;
  901.         }
  902.     }
  903. #ifdef DEBUG
  904.     prtab("ietab", perm, 8);
  905. #endif
  906.     init_perm(IE3264, perm, 4, 8);
  907.  
  908.     /*
  909.      * Compression, then final permutation, then bit reverse.
  910.      */
  911.     for (i = 0; i < 64; i++) {
  912.         k = IP[CIFP[i]-1];
  913.         if (k > 0) {
  914.             k--;
  915.             k = (k|07) - (k&07);
  916.             k++;
  917.         }
  918.         perm[k-1] = i+1;
  919.     }
  920. #ifdef DEBUG
  921.     prtab("cftab", perm, 8);
  922. #endif
  923.     init_perm(CF6464, perm, 8, 8);
  924.  
  925.     /*
  926.      * SPE table
  927.      */
  928.     for (i = 0; i < 48; i++)
  929.         perm[i] = P32Tr[ExpandTr[i]-1];
  930.     for (tableno = 0; tableno < 8; tableno++) {
  931.         for (j = 0; j < 64; j++)  {
  932.             k = (((j >> 0) &01) << 5)|
  933.                 (((j >> 1) &01) << 3)|
  934.                 (((j >> 2) &01) << 2)|
  935.                 (((j >> 3) &01) << 1)|
  936.                 (((j >> 4) &01) << 0)|
  937.                 (((j >> 5) &01) << 4);
  938.             k = S[tableno][k];
  939.             k = (((k >> 3)&01) << 0)|
  940.                 (((k >> 2)&01) << 1)|
  941.                 (((k >> 1)&01) << 2)|
  942.                 (((k >> 0)&01) << 3);
  943.             for (i = 0; i < 32; i++)
  944.                 tmp32[i] = 0;
  945.             for (i = 0; i < 4; i++)
  946.                 tmp32[4 * tableno + i] = (k >> i) & 01;
  947.             k = 0;
  948.             for (i = 24; --i >= 0; )
  949.                 k = (k<<1) | tmp32[perm[i]-1];
  950.             TO_SIX_BIT(SPE[0][tableno][j], k);
  951.             k = 0;
  952.             for (i = 24; --i >= 0; )
  953.                 k = (k<<1) | tmp32[perm[i+24]-1];
  954.             TO_SIX_BIT(SPE[1][tableno][j], k);
  955.         }
  956.     }
  957. }
  958.  
  959. /*
  960.  * Initialize "perm" to represent transformation "p", which rearranges
  961.  * (perhaps with expansion and/or contraction) one packed array of bits
  962.  * (of size "chars_in" characters) into another array (of size "chars_out"
  963.  * characters).
  964.  *
  965.  * "perm" must be all-zeroes on entry to this routine.
  966.  */
  967. STATIC void init_perm(C_block perm[64/CHUNKBITS][1<<CHUNKBITS],
  968.               unsigned char p[64],
  969.               int chars_in,
  970.               int chars_out)
  971. {
  972.     register int i, j, k, l;
  973.  
  974.     for (k = 0; k < chars_out*8; k++) {    /* each output bit position */
  975.         l = p[k] - 1;        /* where this bit comes from */
  976.         if (l < 0)
  977.             continue;    /* output bit is always 0 */
  978.         i = l>>LGCHUNKBITS;    /* which chunk this bit comes from */
  979.         l = 1<<(l&(CHUNKBITS-1));    /* mask for this bit */
  980.         for (j = 0; j < (1<<CHUNKBITS); j++) {    /* each chunk value */
  981.             if ((j & l) != 0)
  982.                 perm[i][j].b[k>>3] |= 1<<(k&07);
  983.         }
  984.     }
  985. }
  986.  
  987. #if 0
  988. /*
  989.  * "setkey" routine (for backwards compatibility)
  990.  */
  991. int setkey(register const char *key)
  992. {
  993.     register int i, j, k;
  994.     C_block keyblock;
  995.  
  996.     for (i = 0; i < 8; i++) {
  997.         k = 0;
  998.         for (j = 0; j < 8; j++) {
  999.             k <<= 1;
  1000.             k |= (unsigned char)*key++;
  1001.         }
  1002.         keyblock.b[i] = k;
  1003.     }
  1004.     return (des_setkey((char *)keyblock.b));
  1005. }
  1006.  
  1007. /*
  1008.  * "encrypt" routine (for backwards compatibility)
  1009.  */
  1010. int encrypt(register char *block, int flag)
  1011. {
  1012.     register int i, j, k;
  1013.     C_block cblock;
  1014.  
  1015.     for (i = 0; i < 8; i++) {
  1016.         k = 0;
  1017.         for (j = 0; j < 8; j++) {
  1018.             k <<= 1;
  1019.             k |= (unsigned char)*block++;
  1020.         }
  1021.         cblock.b[i] = k;
  1022.     }
  1023.     if (des_cipher((char *)&cblock, (char *)&cblock, 0L, (flag ? -1: 1)))
  1024.         return (1);
  1025.     for (i = 7; i >= 0; i--) {
  1026.         k = cblock.b[i];
  1027.         for (j = 7; j >= 0; j--) {
  1028.             *--block = k&01;
  1029.             k >>= 1;
  1030.         }
  1031.     }
  1032.     return (0);
  1033. }
  1034. #endif
  1035.  
  1036. #ifdef DEBUG
  1037. STATIC void prtab(char *s, unsigned char *t, int num_rows)
  1038. {
  1039.     register int i, j;
  1040.  
  1041.     (void)printf("%s:\n", s);
  1042.     for (i = 0; i < num_rows; i++) {
  1043.         for (j = 0; j < 8; j++) {
  1044.              (void)printf("%3d", t[i*8+j]);
  1045.         }
  1046.         (void)printf("\n");
  1047.     }
  1048.     (void)printf("\n");
  1049. }
  1050. #endif
  1051.  
  1052. /****** usergroup.library/ug_GetSalt ***************************************
  1053.  
  1054.     NAME
  1055.         ug_GetSalt - generate password encryption setting for an user
  1056.  
  1057.     SYNOPSIS
  1058.         setting = ug_GetSalt(passwd, buffer, size);
  1059.           D0                   A0      A1     D0
  1060.  
  1061.         UBYTE *ug_GetSalt(const struct passwd *, UBYTE *, ULONG);
  1062.  
  1063.     FUNCTION
  1064.         This function generates a setting parameter, which is used to
  1065.         configure the password encryption process.  If an old entry exists,
  1066.         the new salt depends on it.
  1067.  
  1068.         The particular salt format depends on the system security level.
  1069.  
  1070.     INPUTS
  1071.         passwd - the old passwd entry for the user, or NULL if there is none.
  1072.  
  1073.         buffer - address of character array, which the new salt is stored
  1074.                  in.
  1075.  
  1076.         size   - the number of bytes in the buffer. The buffer should be at
  1077.                  least 12 bytes long. 
  1078.  
  1079.     RETURN VALUE
  1080.         Pointer to the buffer, or NULL if the buffer is too small.
  1081.  
  1082.     NOTE
  1083.         By default the Version 7 UNIX compatible setting is generated.
  1084.  
  1085.     SEE ALSO
  1086.        crypt()
  1087.  
  1088. ****************************************************************************
  1089. */
  1090.  
  1091. SAVEDS ASM char *R_ug_GetSalt(REG(a0) const struct passwd *pw,
  1092.                   REG(a1) char *buffer, 
  1093.                   REG(d0) ULONG size)
  1094. {
  1095.   LONG rv = LRandom();
  1096.  
  1097.   if (size < 12)
  1098.     return NULL;
  1099.  
  1100.   buffer[0] = itoa64[rv & 63];
  1101.   buffer[1] = itoa64[(rv >> 6) & 63];
  1102.   buffer[2] = '\0';
  1103.  
  1104.   return buffer;
  1105. }
  1106.